home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / sun / font / FileFontStrike.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  8.5 KB  |  493 lines
  1. package sun.font;
  2.  
  3. import java.awt.Rectangle;
  4. import java.awt.geom.AffineTransform;
  5. import java.awt.geom.GeneralPath;
  6. import java.awt.geom.NoninvertibleTransformException;
  7. import java.awt.geom.Point2D;
  8. import java.awt.geom.Rectangle2D;
  9. import java.lang.ref.SoftReference;
  10. import java.util.HashMap;
  11. import java.util.concurrent.ConcurrentHashMap;
  12.  
  13. public class FileFontStrike extends PhysicalStrike {
  14.    static final int INVISIBLE_GLYPHS = 65534;
  15.    private FileFont fileFont;
  16.    private static final int UNINITIALISED = 0;
  17.    private static final int INTARRAY = 1;
  18.    private static final int LONGARRAY = 2;
  19.    private static final int SEGINTARRAY = 3;
  20.    private static final int SEGLONGARRAY = 4;
  21.    private int glyphCacheFormat = 0;
  22.    private static final int SEGSHIFT = 8;
  23.    private static final int SEGSIZE = 256;
  24.    private boolean segmentedCache;
  25.    private int[][] segIntGlyphImages;
  26.    private long[][] segLongGlyphImages;
  27.    protected float[] horizontalAdvances;
  28.    ConcurrentHashMap boundsMap;
  29.    SoftReference glyphMetricsMapRef;
  30.    AffineTransform invertDevTx;
  31.    boolean useNatives;
  32.    NativeStrike[] nativeStrikes;
  33.    private static final int SLOTZEROMAX = 16777215;
  34.  
  35.    FileFontStrike(FileFont var1, FontStrikeDesc var2) {
  36.       super(var1, var2);
  37.       this.fileFont = var1;
  38.       if (var2.style != var1.style) {
  39.          if ((var2.style & 2) == 2 && (var1.style & 2) == 0) {
  40.             this.algoStyle = true;
  41.             this.italic = 0.7F;
  42.          }
  43.  
  44.          if ((var2.style & 1) == 1 && (var1.style & 1) == 0) {
  45.             this.algoStyle = true;
  46.             this.boldness = 1.33F;
  47.          }
  48.       }
  49.  
  50.       double[] var3 = new double[4];
  51.       AffineTransform var4 = var2.glyphTx;
  52.       var4.getMatrix(var3);
  53.       if (!var2.devTx.isIdentity() && var2.devTx.getType() != 1) {
  54.          try {
  55.             this.invertDevTx = var2.devTx.createInverse();
  56.          } catch (NoninvertibleTransformException var11) {
  57.          }
  58.       }
  59.  
  60.       if (!Double.isNaN(var3[0]) && !Double.isNaN(var3[1]) && !Double.isNaN(var3[2]) && !Double.isNaN(var3[3])) {
  61.          this.pScalerContext = this.createScalerContext(var1.getScaler(), var3, var1 instanceof TrueTypeFont, var2.aaHint, var2.fmHint, this.algoStyle, this.boldness, this.italic);
  62.       } else {
  63.          this.pScalerContext = getNullScalerContext(FileFont.getNullScaler());
  64.       }
  65.  
  66.       this.mapper = var1.getMapper();
  67.       int var5 = this.mapper.getNumGlyphs();
  68.       float var6 = (float)var3[3];
  69.       int var7 = (int)var6;
  70.       boolean var8 = (var4.getType() & 124) == 0;
  71.       this.segmentedCache = var5 > 4096 || var5 > 512 && (!var8 || var6 != (float)var7 || var7 < 6 || var7 > 36);
  72.       if (this.pScalerContext == 0L) {
  73.          this.disposer = new FontStrikeDisposer(var1, var2);
  74.          this.initGlyphCache();
  75.          this.pScalerContext = getNullScalerContext(FileFont.getNullScaler());
  76.          FontManager.deRegisterBadFont(var1);
  77.       } else {
  78.          if (var1.checkUseNatives() && var2.aaHint == 0 && !this.algoStyle && var3[1] == (double)0.0F && var3[2] == (double)0.0F && var3[0] >= (double)6.0F && var3[0] <= (double)36.0F && var3[0] == var3[3]) {
  79.             this.useNatives = true;
  80.             int var9 = var1.nativeFonts.length;
  81.             this.nativeStrikes = new NativeStrike[var9];
  82.  
  83.             for(int var10 = 0; var10 < var9; ++var10) {
  84.                this.nativeStrikes[var10] = new NativeStrike(var1.nativeFonts[var10], var2, false);
  85.             }
  86.          }
  87.  
  88.          this.disposer = new FontStrikeDisposer(var1, var2, this.pScalerContext);
  89.          this.getImageWithAdvance = var4.getScaleY() <= (double)48.0F || this.segmentedCache;
  90.          if (!this.getImageWithAdvance && var5 < 1000) {
  91.             this.horizontalAdvances = new float[var5];
  92.  
  93.             for(int var12 = 0; var12 < var5; ++var12) {
  94.                this.horizontalAdvances[var12] = Float.MAX_VALUE;
  95.             }
  96.          }
  97.  
  98.       }
  99.    }
  100.  
  101.    static synchronized native long getNullScalerContext(long var0);
  102.  
  103.    private native long createScalerContext(long var1, double[] var3, boolean var4, int var5, int var6, boolean var7, float var8, float var9);
  104.  
  105.    public int getNumGlyphs() {
  106.       return this.fileFont.getNumGlyphs();
  107.    }
  108.  
  109.    long getGlyphImageFromNative(int var1) {
  110.       char var4 = this.fileFont.glyphToCharMap[var1];
  111.  
  112.       for(int var5 = 0; var5 < this.nativeStrikes.length; ++var5) {
  113.          CharToGlyphMapper var6 = this.fileFont.nativeFonts[var5].getMapper();
  114.          int var7 = var6.charToGlyph(var4) & '\uffff';
  115.          if (var7 != var6.getMissingGlyphCode()) {
  116.             long var2 = this.nativeStrikes[var5].getGlyphImagePtrNoCache(var7);
  117.             if (var2 != 0L) {
  118.                return var2;
  119.             }
  120.          }
  121.       }
  122.  
  123.       return this.fileFont.getGlyphImage(this.pScalerContext, var1);
  124.    }
  125.  
  126.    long getGlyphImagePtr(int var1) {
  127.       if (var1 >= 65534) {
  128.          return StrikeCache.invisibleGlyphPtr;
  129.       } else {
  130.          long var2;
  131.          if ((var2 = this.getCachedGlyphPtr(var1)) != 0L) {
  132.             return var2;
  133.          } else {
  134.             if (this.useNatives) {
  135.                var2 = this.getGlyphImageFromNative(var1);
  136.             } else {
  137.                var2 = this.fileFont.getGlyphImage(this.pScalerContext, var1);
  138.             }
  139.  
  140.             return this.setCachedGlyphPtr(var1, var2);
  141.          }
  142.       }
  143.    }
  144.  
  145.    void getGlyphImagePtrs(int[] var1, long[] var2, int var3) {
  146.       for(int var4 = 0; var4 < var3; ++var4) {
  147.          int var5 = var1[var4];
  148.          if (var5 >= 65534) {
  149.             var2[var4] = StrikeCache.invisibleGlyphPtr;
  150.          } else if ((var2[var4] = this.getCachedGlyphPtr(var5)) == 0L) {
  151.             long var6;
  152.             if (this.useNatives) {
  153.                var6 = this.getGlyphImageFromNative(var5);
  154.             } else {
  155.                var6 = this.fileFont.getGlyphImage(this.pScalerContext, var5);
  156.             }
  157.  
  158.             var2[var4] = this.setCachedGlyphPtr(var5, var6);
  159.          }
  160.       }
  161.  
  162.    }
  163.  
  164.    int getSlot0GlyphImagePtrs(int[] var1, long[] var2, int var3) {
  165.       int var4 = 0;
  166.  
  167.       for(int var5 = 0; var5 < var3; ++var5) {
  168.          int var6 = var1[var5];
  169.          if (var6 >= 16777215) {
  170.             return var4;
  171.          }
  172.  
  173.          ++var4;
  174.          if (var6 >= 65534) {
  175.             var2[var5] = StrikeCache.invisibleGlyphPtr;
  176.          } else if ((var2[var5] = this.getCachedGlyphPtr(var6)) == 0L) {
  177.             long var7;
  178.             if (this.useNatives) {
  179.                var7 = this.getGlyphImageFromNative(var6);
  180.             } else {
  181.                var7 = this.fileFont.getGlyphImage(this.pScalerContext, var6);
  182.             }
  183.  
  184.             var2[var5] = this.setCachedGlyphPtr(var6, var7);
  185.          }
  186.       }
  187.  
  188.       return var4;
  189.    }
  190.  
  191.    long getCachedGlyphPtr(int var1) {
  192.       switch (this.glyphCacheFormat) {
  193.          case 1:
  194.             return (long)this.intGlyphImages[var1] & 4294967295L;
  195.          case 2:
  196.             return this.longGlyphImages[var1];
  197.          case 3:
  198.             int var4 = var1 >> 8;
  199.             if (this.segIntGlyphImages[var4] != null) {
  200.                int var5 = var1 % 256;
  201.                return (long)this.segIntGlyphImages[var4][var5] & 4294967295L;
  202.             }
  203.  
  204.             return 0L;
  205.          case 4:
  206.             int var2 = var1 >> 8;
  207.             if (this.segLongGlyphImages[var2] != null) {
  208.                int var3 = var1 % 256;
  209.                return this.segLongGlyphImages[var2][var3];
  210.             }
  211.  
  212.             return 0L;
  213.          default:
  214.             return 0L;
  215.       }
  216.    }
  217.  
  218.    private synchronized long setCachedGlyphPtr(int var1, long var2) {
  219.       switch (this.glyphCacheFormat) {
  220.          case 1:
  221.             if (this.intGlyphImages[var1] == 0) {
  222.                this.intGlyphImages[var1] = (int)var2;
  223.                return var2;
  224.             }
  225.  
  226.             StrikeCache.freeIntPointer((int)var2);
  227.             return (long)this.intGlyphImages[var1] & 4294967295L;
  228.          case 2:
  229.             if (this.longGlyphImages[var1] == 0L) {
  230.                this.longGlyphImages[var1] = var2;
  231.                return var2;
  232.             }
  233.  
  234.             StrikeCache.freeLongPointer(var2);
  235.             return this.longGlyphImages[var1];
  236.          case 3:
  237.             int var6 = var1 >> 8;
  238.             int var7 = var1 % 256;
  239.             if (this.segIntGlyphImages[var6] == null) {
  240.                this.segIntGlyphImages[var6] = new int[256];
  241.             }
  242.  
  243.             if (this.segIntGlyphImages[var6][var7] == 0) {
  244.                this.segIntGlyphImages[var6][var7] = (int)var2;
  245.                return var2;
  246.             }
  247.  
  248.             StrikeCache.freeIntPointer((int)var2);
  249.             return (long)this.segIntGlyphImages[var6][var7] & 4294967295L;
  250.          case 4:
  251.             int var4 = var1 >> 8;
  252.             int var5 = var1 % 256;
  253.             if (this.segLongGlyphImages[var4] == null) {
  254.                this.segLongGlyphImages[var4] = new long[256];
  255.             }
  256.  
  257.             if (this.segLongGlyphImages[var4][var5] == 0L) {
  258.                this.segLongGlyphImages[var4][var5] = var2;
  259.                return var2;
  260.             }
  261.  
  262.             StrikeCache.freeLongPointer(var2);
  263.             return this.segLongGlyphImages[var4][var5];
  264.          default:
  265.             this.initGlyphCache();
  266.             return this.setCachedGlyphPtr(var1, var2);
  267.       }
  268.    }
  269.  
  270.    private void initGlyphCache() {
  271.       int var1 = this.mapper.getNumGlyphs();
  272.       if (this.segmentedCache) {
  273.          int var2 = (var1 + 256 - 1) / 256;
  274.          if (FontManager.longAddresses) {
  275.             this.glyphCacheFormat = 4;
  276.             this.segLongGlyphImages = new long[var2][];
  277.             this.disposer.segLongGlyphImages = this.segLongGlyphImages;
  278.          } else {
  279.             this.glyphCacheFormat = 3;
  280.             this.segIntGlyphImages = new int[var2][];
  281.             this.disposer.segIntGlyphImages = this.segIntGlyphImages;
  282.          }
  283.       } else if (FontManager.longAddresses) {
  284.          this.glyphCacheFormat = 2;
  285.          this.longGlyphImages = new long[var1];
  286.          this.disposer.longGlyphImages = this.longGlyphImages;
  287.       } else {
  288.          this.glyphCacheFormat = 1;
  289.          this.intGlyphImages = new int[var1];
  290.          this.disposer.intGlyphImages = this.intGlyphImages;
  291.       }
  292.  
  293.    }
  294.  
  295.    float getGlyphAdvance(int var1) {
  296.       if (var1 >= 65534) {
  297.          return 0.0F;
  298.       } else {
  299.          if (this.horizontalAdvances != null) {
  300.             float var2 = this.horizontalAdvances[var1];
  301.             if (var2 != Float.MAX_VALUE) {
  302.                return var2;
  303.             }
  304.          }
  305.  
  306.          float var5;
  307.          if (this.invertDevTx != null) {
  308.             var5 = this.getGlyphMetrics(var1).x;
  309.          } else {
  310.             long var3;
  311.             if (this.getImageWithAdvance) {
  312.                var3 = this.getGlyphImagePtr(var1);
  313.             } else {
  314.                var3 = this.getCachedGlyphPtr(var1);
  315.             }
  316.  
  317.             if (var3 != 0L) {
  318.                var5 = StrikeCache.unsafe.getFloat(var3 + (long)StrikeCache.xAdvanceOffset);
  319.             } else {
  320.                var5 = this.fileFont.getGlyphAdvance(this.pScalerContext, var1);
  321.             }
  322.          }
  323.  
  324.          if (this.horizontalAdvances != null) {
  325.             this.horizontalAdvances[var1] = var5;
  326.          }
  327.  
  328.          return var5;
  329.       }
  330.    }
  331.  
  332.    float getCodePointAdvance(int var1) {
  333.       return this.getGlyphAdvance(this.mapper.charToGlyph(var1));
  334.    }
  335.  
  336.    void getGlyphImageBounds(int var1, Point2D.Float var2, Rectangle var3) {
  337.       long var4 = this.getGlyphImagePtr(var1);
  338.       float var6 = StrikeCache.unsafe.getFloat(var4 + (long)StrikeCache.topLeftXOffset);
  339.       float var7 = StrikeCache.unsafe.getFloat(var4 + (long)StrikeCache.topLeftYOffset);
  340.       var3.x = (int)Math.floor((double)(var2.x + var6));
  341.       var3.y = (int)Math.floor((double)(var2.y + var7));
  342.       var3.width = StrikeCache.unsafe.getShort(var4 + (long)StrikeCache.widthOffset) & '\uffff';
  343.       var3.height = StrikeCache.unsafe.getShort(var4 + (long)StrikeCache.heightOffset) & '\uffff';
  344.       if ((this.desc.aaHint == 4 || this.desc.aaHint == 5) && var6 <= -2.0F) {
  345.          int var8 = this.getGlyphImageMinX(var4, var3.x);
  346.          if (var8 > var3.x) {
  347.             ++var3.x;
  348.             --var3.width;
  349.          }
  350.       }
  351.  
  352.    }
  353.  
  354.    private int getGlyphImageMinX(long var1, int var3) {
  355.       char var4 = StrikeCache.unsafe.getChar(var1 + (long)StrikeCache.widthOffset);
  356.       char var5 = StrikeCache.unsafe.getChar(var1 + (long)StrikeCache.heightOffset);
  357.       char var6 = StrikeCache.unsafe.getChar(var1 + (long)StrikeCache.rowBytesOffset);
  358.       if (var6 == var4) {
  359.          return var3;
  360.       } else {
  361.          long var7;
  362.          if (StrikeCache.nativeAddressSize == 4) {
  363.             var7 = (long)(-1 & StrikeCache.unsafe.getInt(var1 + (long)StrikeCache.pixelDataOffset));
  364.          } else {
  365.             var7 = StrikeCache.unsafe.getLong(var1 + (long)StrikeCache.pixelDataOffset);
  366.          }
  367.  
  368.          if (var7 == 0L) {
  369.             return var3;
  370.          } else {
  371.             for(int var9 = 0; var9 < var5; ++var9) {
  372.                for(int var10 = 0; var10 < 3; ++var10) {
  373.                   if (StrikeCache.unsafe.getByte(var7 + (long)(var9 * var6) + (long)var10) != 0) {
  374.                      return var3;
  375.                   }
  376.                }
  377.             }
  378.  
  379.             return var3 + 1;
  380.          }
  381.       }
  382.    }
  383.  
  384.    StrikeMetrics getFontMetrics() {
  385.       if (this.strikeMetrics == null) {
  386.          this.strikeMetrics = this.fileFont.getFontMetrics(this.pScalerContext);
  387.          if (this.invertDevTx != null) {
  388.             this.strikeMetrics.convertToUserSpace(this.invertDevTx);
  389.          }
  390.       }
  391.  
  392.       return this.strikeMetrics;
  393.    }
  394.  
  395.    Point2D.Float getGlyphMetrics(int var1) {
  396.       Point2D.Float var2 = new Point2D.Float();
  397.       if (var1 >= 65534) {
  398.          return var2;
  399.       } else {
  400.          long var3;
  401.          if (this.getImageWithAdvance) {
  402.             var3 = this.getGlyphImagePtr(var1);
  403.          } else {
  404.             var3 = this.getCachedGlyphPtr(var1);
  405.          }
  406.  
  407.          if (var3 != 0L) {
  408.             var2 = new Point2D.Float();
  409.             var2.x = StrikeCache.unsafe.getFloat(var3 + (long)StrikeCache.xAdvanceOffset);
  410.             var2.y = StrikeCache.unsafe.getFloat(var3 + (long)StrikeCache.yAdvanceOffset);
  411.             if (this.invertDevTx != null) {
  412.                this.invertDevTx.deltaTransform(var2, var2);
  413.             }
  414.          } else {
  415.             Integer var5 = new Integer(var1);
  416.             Point2D.Float var6 = null;
  417.             HashMap var7 = null;
  418.             if (this.glyphMetricsMapRef != null) {
  419.                var7 = (HashMap)this.glyphMetricsMapRef.get();
  420.             }
  421.  
  422.             if (var7 != null) {
  423.                synchronized(this) {
  424.                   var6 = (Point2D.Float)var7.get(var5);
  425.                   if (var6 != null) {
  426.                      var2.x = var6.x;
  427.                      var2.y = var6.y;
  428.                      return var2;
  429.                   }
  430.                }
  431.             }
  432.  
  433.             if (var6 == null) {
  434.                this.fileFont.getGlyphMetrics(this.pScalerContext, var1, var2);
  435.                if (this.invertDevTx != null) {
  436.                   this.invertDevTx.deltaTransform(var2, var2);
  437.                }
  438.  
  439.                var6 = new Point2D.Float(var2.x, var2.y);
  440.                synchronized(this) {
  441.                   if (var7 == null) {
  442.                      var7 = new HashMap();
  443.                      this.glyphMetricsMapRef = new SoftReference(var7);
  444.                   }
  445.  
  446.                   var7.put(var5, var6);
  447.                }
  448.             }
  449.          }
  450.  
  451.          return var2;
  452.       }
  453.    }
  454.  
  455.    Point2D.Float getCharMetrics(char var1) {
  456.       return this.getGlyphMetrics(this.mapper.charToGlyph(var1));
  457.    }
  458.  
  459.    Rectangle2D.Float getGlyphOutlineBounds(int var1) {
  460.       if (this.boundsMap == null) {
  461.          this.boundsMap = new ConcurrentHashMap();
  462.       }
  463.  
  464.       Integer var2 = new Integer(var1);
  465.       Rectangle2D.Float var3 = (Rectangle2D.Float)this.boundsMap.get(var2);
  466.       if (var3 == null) {
  467.          var3 = this.fileFont.getGlyphOutlineBounds(this.pScalerContext, var1);
  468.          this.boundsMap.put(var2, var3);
  469.       }
  470.  
  471.       return var3;
  472.    }
  473.  
  474.    public Rectangle2D getOutlineBounds(int var1) {
  475.       return this.fileFont.getGlyphOutlineBounds(this.pScalerContext, var1);
  476.    }
  477.  
  478.    GeneralPath getGlyphOutline(int var1, float var2, float var3) {
  479.       return this.fileFont.getGlyphOutline(this.pScalerContext, var1, var2, var3);
  480.    }
  481.  
  482.    GeneralPath getGlyphVectorOutline(int[] var1, float var2, float var3) {
  483.       return this.fileFont.getGlyphVectorOutline(this.pScalerContext, var1, var1.length, var2, var3);
  484.    }
  485.  
  486.    protected void adjustPoint(Point2D.Float var1) {
  487.       if (this.invertDevTx != null) {
  488.          this.invertDevTx.deltaTransform(var1, var1);
  489.       }
  490.  
  491.    }
  492. }
  493.